package com.z.utils;

import org.apache.commons.lang3.StringUtils;
import org.joda.time.*;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class DateUtilsMzywx {

	/** 日期 */
	public final static String DEFAILT_DATE_PATTERN = "yyyy-MM-dd";
	/** 日期时间 */
	public final static String DEFAILT_DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
	/** 时间 */
	public final static String DEFAULT_TIME_PATTERN = "HH:mm:ss";
	/**
	 * 每天的毫秒数
	 */
	public final static long MILLIS_IN_DAY = 1000 * 60 * 60 * 24;
	
	
	/**
	 * 判断指定日期是否是周六，周日
	 * @param dt
	 * @return
	 * @throws Exception
	 */
	public static boolean isWeekOfDate(Date dt) {
		String str = DateUtilsMzywx.convertDate2Week(dt);
        if(str.equals("星期六") || str.equals("星期日")){
        	return true;
        }else{
        	return false;
        }
    }

	/**
	 * 转换日期字符串得到指定格式的日期类型
	 * 
	 * @author zhangyv
	 * @param formatString
	 *            需要转换的格式字符串（例："yyyy-MM" or "yyyy-MM-dd" or "yyyy-MM-dd HH" 等日期的规范标记的组合）
	 * @param targetDate
	 *            需要转换的时间
	 * @return
	 * 		例	convertString2Date("2015-11-10 10:52","yyyy-MM-dd HH:mm");
	 * @throws ParseException
	 */
	public static final Date convertString2Date(String formatString, String targetDate)
			throws ParseException {
		if (StringUtils.isBlank(targetDate))
			return null;
		SimpleDateFormat format = null;
		Date result = null;
		format = new SimpleDateFormat(formatString);
		try {
			result = format.parse(targetDate);
		} catch (ParseException pe) {
			throw new ParseException(pe.getMessage(), pe.getErrorOffset());
		}
		return result;
	}

	
	/**
	 * 转换字符串得到默认格式的日期类型
	 * 
	 * @author zhangyv
	 * 
	 * @param strDate
	 * 		格式必须为:"yyyy-MM-dd"
	 * @return
	 * 		例	convertString2Date("2015-01-01");
	 * @throws ParseException
	 */
	public static Date convertString2Date(String strDate) throws ParseException {
		Date result = null;
		try {
			result = convertString2Date(DEFAILT_DATE_PATTERN, strDate);
		} catch (ParseException pe) {
			throw new ParseException(pe.getMessage(), pe.getErrorOffset());
		}
		return result;
	}
	
	
	
	
	/**
	 * 转换字符串得到其对应日期时间的一个毫秒数
	 * 
	 * @author zhangyv
	 * 
	 * @param strDate	
	 * 		需要转换日期字符串,格式必须为"yyyy-MM-dd"
	 * @return
	 * 		例	convertString2LongDate("2015-01-01");
	 * @throws ParseException
	 */
	public static Long convertString2LongDate(String strDate) throws ParseException {
		Long result = null;
		try {
			result = convertString2Date(strDate).getTime();
		} catch (ParseException pe) {
			throw new ParseException(pe.getMessage(), pe.getErrorOffset());
		}
		return result;
	}
	
	/**
	 * 转换日期字符串得到指定格式的日期类型
	 * 
	 * @author zhangyv
	 * 
	 * @param formatString
	 *            需要转换的格式字符串（例：yyyy-MM or yyyy-MM-dd or yyyy-MM-dd HH 等日期的规范标记的组合）
	 * @param targetDate
	 *            需要转换的时间
	 * @return
	 * 		例	convertString2LongDate("yyyy-MM-dd HH","2015-01-01 01");
	 * 			convertString2LongDate("yyyy-MM-dd HH:mm:ss","2015-01-01 01:20:03");
	 * @throws ParseException
	 */
	public static final Long convertString2LongDate(String formatString, String targetDate)
			throws ParseException {
		Long result = null;
		try {
			result = convertString2Date(formatString,targetDate).getTime();
		} catch (ParseException pe) {
			throw new ParseException(pe.getMessage(), pe.getErrorOffset());
		}
		return result;
	}

	/**
	 * 转换日期得到指定格式的日期字符串
	 * 
	 * @param formatString
	 *            需要把目标日期格式化什么样子的格式。例如,yyyy-MM-dd HH:mm:ss
	 * @param targetDate
	 *            目标日期
	 * @return
	 */
	public static String convertDate2String(String formatString, Date targetDate) {
		SimpleDateFormat format = null;
		String result = null;
		if (targetDate != null) {
			format = new SimpleDateFormat(formatString);
			result = format.format(targetDate);
		} else {
			return null;
		}
		return result;
	}

	/**
	 * 转换日期,得到默认日期格式字符串
	 * 
	 * @param targetDate
	 * @return
	 */
	public static String convertDate2String(Date targetDate) {
		return convertDate2String(DEFAILT_DATE_PATTERN, targetDate);
	}
	
	
	/**
	 * 获取当前日期的年月日　字符串型数据
	 * 格式为"yyyy-MM-dd"
	 * 
	 */
	public static String getCurrentDate() {
		Date date = new Date();
		return DateUtilsMzywx.convertDate2String("yyyy-MM-dd",date);
	}
	
	/**
	 * 获取当前日期的年月日　时分秒为零的日期格式
	 * @throws ParseException 
	 * 
	 */
	public static Date getCurrentDate_date() throws ParseException {
		String date = getCurrentDate();
		return DateUtilsMzywx.convertString2Date("yyyy-MM-dd", date);
	}
	
	/**
	 * 格式化指定日期　(按指定的格式，格式不涉及的尾部格式成0)
	 *　
	 *　
	 * @return　日期 date =　2014-12-12 12:05:85 888  
	 * 			formatDate_date("yyyy-MM-dd HH",date);
	 * 			返回值为　Date　值为　2014-12-12 12:00:00 888
	 * @throws ParseException
	 */
	public static Date formatDate_date(String formatString, Date targetDate) throws ParseException {
		String date = convertDate2String(formatString,targetDate);
		return DateUtilsMzywx.convertString2Date(formatString, date);
	}
	
	/**
	 * 格式化指定日期　时分秒为零的日期
	 * @throws ParseException 
	 * 
	 */
	public static Date formatDate_date( Date targetDate) throws ParseException {
		String date = convertDate2String("yyyy-MM-dd",targetDate);
		return DateUtilsMzywx.convertString2Date(date);
	}
	
	
	/**
	 * 格式化指定日期　时分秒为零的日期
	 * 格式为"yyyy-MM-dd" 
	 * 
	 */
	public static String formatDate(Date targetDate) throws ParseException {
		return DateUtilsMzywx.convertDate2String("yyyy-MM-dd", targetDate);
	}
	
	
	/**
	 * 格式化指定日期　时分秒为零的日期格式
	 * 格式为"yyyy-MM-dd"
	 * 
	 */
//	public static String formatDate(String formatString, Date targetDate) throws ParseException {
//		String date = getCurrentDate();
//		return DateUtils.convertString2Date("yyyy-MM-dd", date);
//	}
	
	
	
	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的天数)
	 * 
	 * @return Date 指定的日期i天前（后）的日期
	 * 
	 *         往前或后推几日(正数往前，负数往后)
	 */
	public static Date plusDateC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusDays(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的月数)
	 * 
	 * @return Date 指定的日期i月前（后）的日期
	 * 
	 *         往前或后推月(正数往前，负数往后)
	 */
	public static Date plusMonthC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusMonths(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的年数)
	 * 
	 * @return Date 指定的日期i年前（后）的日期
	 * 
	 *         往前或后推年(正数往前，负数往后)
	 */
	public static Date plusYearC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusYears(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的小时数)
	 * 
	 * @return Date 指定的日期i小时前（后）的日期
	 * 
	 *         往前或后推小时(正数往前，负数往后)
	 */
	public static Date plusHourC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusHours(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的分钟数)
	 * 
	 * @return Date 指定的日期i分钟前（后）的日期
	 * 
	 *         往前或后推分钟(正数往前，负数往后)
	 */
	public static Date plusMinuteC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusMinutes(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的周数)
	 * 
	 * @return Date 指定的日期i周前（后）的日期
	 * 
	 *         往前或后推周(正数往前，负数往后)
	 */
	public static Date plusWeekC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusWeeks(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的天数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的天数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTDays(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Days dS = Days.daysBetween(dt, dt1);
		int kd = dS.getDays();
		return kd;
	}
	
	
	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的天数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的天数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int betweenDays(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Days dS = Days.daysBetween(dt, dt1);
		int kd = dS.getDays();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的月数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的月数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTMonths(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Months dS = Months.monthsBetween(dt, dt1);
		int kd = dS.getMonths();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的年数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的年数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTYears(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Years dS = Years.yearsBetween(dt, dt1);
		int kd = dS.getYears();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的小时数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的小时数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTHours(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Hours dS = Hours.hoursBetween(dt, dt1);
		int kd = dS.getHours();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的分钟数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的分钟数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTMinutes(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Minutes dS = Minutes.minutesBetween(dt, dt1);
		int kd = dS.getMinutes();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的周数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的周数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTWeeks(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Weeks dS = Weeks.weeksBetween(dt, dt1);
		int kd = dS.getWeeks();
		return kd;
	}
	
	/**
	 * 获取当前日期的星期
	 * @param date
	 * @return 当前日期星期
	 */
	public static String convertDate2Week(Date date) {
		String[] weekDays = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		int w = calendar.get(Calendar.DAY_OF_WEEK) - 1;
		if (w < 0) {
			w = 0;
		}
		return weekDays[w];
	}
	
	/**
	 * 获取从指定日期向后推指定月份之间的天数
	 * @param startDay 开始日期
	 * @param monthNum 指定月份
	 * @return
	 */
	public static int getDays(String startDay, int monthNum) {
		try {
			String format = "yyyy-MM-dd";
			Date start = DateUtilsMzywx.convertString2Date(format, startDay);
			Date end = DateUtilsMzywx.plusMonthC(start, monthNum);
			int betweenDay = DateUtilsMzywx.betweenDays(start, end);
			return betweenDay < 1 ? 0 : betweenDay;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return -1;
	}

	/**
	 * 获取指定月份的最后一天日期格式"yyyy-MM-dd"
	 * @param month 要求格式 "yyyy-MM";
	 * @return 指定月份的最后一天日期格式"yyyy-MM-dd"
	 */
	public static String getMonthLastDate(String month) {
		try {
			String[] array = month.split("-");
			int y = Integer.valueOf(array[0]);
			int m = Integer.valueOf(array[1]);
			switch (m) {
				case 2:
					if ((y % 100 == 0 && y % 400 == 0) || y % 4 == 0) {
						return month + "-" + 29;
					} 
					return month + "-" + 28;
				case 4:
				case 6:
				case 9:
				case 11:
					return month + "-" + 30;
				default:
					return month + "-" + 31;
			}
		} catch (NumberFormatException e) {
			e.printStackTrace();
		}
		return "2017-01-31";
	}
	
	/**
	 * 获取两个指定日期之间的所有日期
	 * @param start 开始日期 格式yyyy-MM-dd
	 * @param end 结束日期 格式yyyy-MM-dd
	 * @return 例如传入2017-01-01 2017-01-04 返回【2017-01-02 2017-01-03】
	 */
	public static List<String> getMiddleDate(String start, String end) {
		List<String> result = new ArrayList<String>();
		String format = "yyyy-MM-dd";
		try {
			Date startDate = DateUtilsMzywx.convertString2Date(format, start);
			int days = DateUtilsMzywx.betweenDays(startDate, DateUtilsMzywx.convertString2Date(format, end));
			if (days > 1) {
				for (int i = 1; i < days; i++) {
					result.add(DateUtilsMzywx.convertDate2String("yyyy-MM-dd", DateUtilsMzywx.plusDateC(startDate, i)));
				}
			}
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return result;
	}
//	/**
//	 * 作者：张雨
//	 * 
//	 * @param Date
//	 *            d（待比较的时间）
//	 * @param Date
//	 *            d1 (基准的时间-----一般是当前日期)
//	 * @param int tian (本月内的指定的天数)
//	 * @param int riqi（次月几号之前包括该日）
//	 * 
//	 * @return true or false (表示有权限或无权限)
//	 * 
//	 *         根据一月中的限定天数，和下个月的限制日期,返回true和false; 第一个参数待比较的日期，第二个参数是比较的基准,
//	 *         例如：工作量分解里边的审核权限，这样判断今日是否有对某条记录的审核权限,
//	 *         (本月的记录，本月在7天内可以审核，如果是上个月的记录那这个月的2号之后就不可以审核了，
//	 *         如：2009-01-02的记录在2009-01-08之后就不可以审核了（也就是说周一添的周日过后就不可以审核），（如：例1）
//	 *         2009-01-28的记录在2009-02-02可以审核，在2009-02-03以及之后就不可以审核了，（如：例2）)
//	 * 
//	 *         方法示例： 例1： Date d = new Date(109,0,2); Date d1 = new
//	 *         Date(109,0,8); Boolean r = this.isDatePower(d,d1,7,2); 结果为true
//	 * 
//	 *         Date d = new Date(109,0,2); Date d1 = new Date(109,0,9); Boolean
//	 *         r = this.isDatePower(d,d1,7,2); 结果为false
//	 * 
//	 *         例2: Date d = new Date(109,0,28); Date d1 = new Date(109,1,2);
//	 *         Boolean r = this.isDatePower(d,d1,7,2); 结果为true
//	 * 
//	 *         Date d = new Date(109,0,28); Date d1 = new Date(109,1,3); Boolean
//	 *         r = this.isDatePower(d,d1,7,2); 结果为false 这里的参数天是包括当天，日期也是包括当日
//	 */
//	public static Boolean isDatePower(Date d, Date d1, int tian, int riqi) {
//
//		// 一般审核都是添加记录之后，所以先比较待比较日期是否是在当日之前
//		Boolean isBefor = d.before(d1);
//		if (isBefor) {
//			// 把两个日期的时分秒去掉
//			d = new Date(d.getYear(), d.getMonth(), d.getDate());
//			d1 = new Date(d1.getYear(), d1.getMonth(), d1.getDate());
//
//			// 看两日期相距的天数
//			int tianShu = DateUtils.bTDays(d, d1);
//			// 相隔的天数小于指定的天，则就说明是在指定天数之内
//			if (tianShu < tian) {
//				// 如果在同一个月的话，有权限
//				if (d.getMonth() == d1.getMonth()) {
//					return true;
//				} else {
//					// 如果不在同一个月也就是出现跨月情况，那看当前日期是不是在指定日期之前
//					if (d1.getDate() <= riqi) {
//						return true;
//					} else {
//						// 不在指定日期之前没权限
//						return false;
//					}
//				}
//			} else {
//				// 相隔不在指定天数之内没权限
//				return false;
//			}
//		} else {
//			// 待比较日期在参照日期之后没权限
//			return false;
//		}
//
//	}

//	/**
//	 * 作者：张雨
//	 * 
//	 * @param Date
//	 *            d（基准日期——————一般是当前日期）
//	 * @param int tian (本月内的指定的天数之前的日期，如果是七天内那就是说六天前)
//	 * @param int riqi（次月几号之前包括该日）
//	 * 
//	 * @return Date型数据(返加一个最小日期型的数据)表示最早可操作那天的记录（返回那天的日期）
//	 * 
//	 *         日期型参数是一个基准
//	 *         例如：工作量分解里边的添加的日期权限限制，每月二号之后就不可以添加上月的工作量，本月中可以添加带今天往前七天内的工作量
//	 *         (及最小的日期就是六天前)
//	 *         (如：2009-01-08可以添加2009-01-02到2009-01-08这段日期内的工作量（如：例1）
//	 *         2009-02-02可以添加2009-01-27到2009-02-02的工作量记录（如：例2）)
//	 *         2009-02-03到2009-02-06则最前可以添加2009-02-01的工作量记录（如：例3）)
//	 * 
//	 *         方法示例： 例1： Date d = new Date(109,0,8); Date d1 =
//	 *         this.minDatePower(d,7,2); 结果为2009-01-02
//	 * 
//	 *         例2: Date d = new Date(109,1,2); Date r =
//	 *         this.minDatePower(d,7,2); 结果为2009-01-27
//	 * 
//	 *         例3: Date d = new Date(109,1,3); Date r =
//	 *         this.minDatePower(d,7,2); 结果为2009-02-01
//	 * 
//	 *         Date d = new Date(109,1,6); Date r = this.minDatePower(d,7,2);
//	 *         结果为2009-02-01 这里的参数天是包括当天，日期也是包括当日
//	 */
//	public static Date minDatePower(Date d, int tian, int riqi) {
//
//		// 把这个时间截成整时间把分秒时都去掉
//		d = new Date(d.getYear(), d.getMonth(), d.getDate());
//
//		// 一个要返回的日期
//		Date date1 = null;
//
//		// 如果规定是：可以添加以基准日期为准往前的七天内的工作记录，且下个月二号之号就不可添加上月的记录，那就是二号之前或六号之后返加六天前日期(正好带当天是七天内)，否则返加当月第一天。
//		if (!(d.getDate() > riqi && d.getDate() < tian)) {
//			// 得到六天前的日期
//			date1 = DateUtils.plusDateC(d, -(tian - 1));
//		} else {
//			// 如果到指定日期之后，最小只能返回这个月的第一天这个日期
//			date1 = new Date(d.getYear(), d.getMonth(), 1);
//		}
//		return date1;
//
//	}

//	/**
//	 * 作者：张雨
//	 * 
//	 * @param Date
//	 *            d（待比较的时间）
//	 * 
//	 * @param Date
//	 *            d1（基准日期------一般是当前日期 ）
//	 * 
//	 * @param int riqi（次月几号之前包括该日）
//	 * 
//	 * @return true or false (表示有权限或无权限)
//	 * 
//	 *         例如：工作量分解里边删除和修改的时间权限限制 (本月的记录，本月本月有权限删除和修改，（下个月到2号之后就不可以再进行删除和修改）
//	 *         如：2009-01-02的记录在2009-01-02到2009-02-02这段时间可以修改和删除，
//	 *         而2009-02-02之后就不可删除和修改了（如：例1）
//	 * 
//	 *         方法示例： 例1： Date d = new Date(109,0,2); Date d1 = new
//	 *         Date(109,0,8); Boolean r = this.updatePower(d,d1,2); 结果为true
//	 * 
//	 *         Date d = new Date(109,0,2); Date d1 = new Date(109,1,2); Boolean
//	 *         r = this.updatePower(d,d1,2); 结果为true
//	 * 
//	 *         Date d = new Date(109,0,2); Date d1 = new Date(109,1,3); Boolean
//	 *         r = this.updatePower(d,d1,2); 结果为false
//	 * 
//	 *         日期也是包括当日
//	 */
//	public static boolean updatePower(Date date1, Date date2, int riqi) throws Exception {
//		Date upDelNowDate = date2;
//
//		// 发生日期在当前日期之前才可以有权限
//		if (date1.before(upDelNowDate)) {
//
//			// 如果在本月内有权限
//			if (date1.getMonth() == upDelNowDate.getMonth()
//					&& date1.getYear() == upDelNowDate.getYear()) {
//				return true;
//			} else {
//				// 得到两个日期当月的有第一天（用于判断是不是上一个月）
//				date1 = new Date(date1.getYear(), date1.getMonth(), 1);
//				date2 = new Date(date2.getYear(), date2.getMonth(), 1);
//
//				// 当基日期往前推一个月看是不是那个待比较的日期
//				date2 = DateUtils.plusMonthC(date2, -1);
//				// 是上一个月时
//				if (date2.getTime() == date1.getTime()) {
//					// 在指定的日期后没权限
//					if (upDelNowDate.getDate() > riqi) {
//						return false;
//					}
//					return true;
//				} else {
//					// 不是上一个月没权限
//					return false;
//				}
//			}
//		} else {
//			// 发生日期在当前日期之后没有权限
//			return false;
//		}
//	}
	


	public static void main(String[] args) {
		List<String> list = DateUtilsMzywx.getMiddleDate("2017-06-28", "2017-07-03");
		for (String string : list) {
			System.out.println(string);
		}
		
		
		
//		try {
//			//今天
//			Date date = DateUtils.getCurrentDate_date();
//			System.out.println(DateUtils.convertDate2String("yyyy-MM-dd HH:mm:ss SSS", date));
//			String date_String = DateUtils.getCurrentDate();
//			System.out.println(date_String);
//			Date date1 = DateUtils.convertString2Date("yyyy-MM-dd HH:mm:ss", "2014-12-12 12:23:08");
//			String date1a = DateUtils.formatDate(date1);
//			Date date1b = DateUtils.formatDate_date(date1);
//			Date date1c = DateUtils.formatDate_date("yyyy-MM-dd HH:mm", date1);
//			System.out.println(date1a);
//			System.out.println(DateUtils.convertDate2String("yyyy-MM-dd HH:mm:ss SSS", date1b));
//			System.out.println(DateUtils.convertDate2String("yyyy-MM-dd HH:mm:ss SSS", date1c));
//		} catch (ParseException e) {
//			e.printStackTrace();
//		}
		
		
		
//		Date date = null;
//		try {
//			date = DateUtils.convertString2Date("2014-01-31");
//		} catch (ParseException e1) {
//			e1.printStackTrace();
//		}
//		Date date1 = DateUtils.plusMonthC(date, 1);
//		System.out.println(DateUtils.convertDate2String(date1));
//		try {
//		} catch (Exception e) {
//
//		}
	}

	public static String getCurrentDateTime() {
		return DateUtilsMzywx.convertDate2String("yyyy-MM-dd HH:mm:ss", new Date());
	}

}
